Programming a Multiplayer FPS in DirectX/Programming a Multiplayer FPS in DirectX (Companion CD).iso/DirectX/dxsdk_oct2004.exe/dxsdk.exe/Samples/C++/DirectInput/MultiMapper/multimapper.cpp

C/C++ Source or Header | 2004-09-27 | 51.6 KB | 1,360 lines

//-----------------------------------------------------------------------------
// File: MultiMapper.cpp
//
// Desc: This is a simple sample to demonstrate how to code using the DInput
//       action mapper feature.
//
//-----------------------------------------------------------------------------
#define STRICT
#define DIRECTINPUT_VERSION 0x0800

#include <windows.h>
#include <commctrl.h>
#include <basetsd.h>
#include <math.h>
#include <stdio.h>
#include <dxerr9.h>
#include <tchar.h>
#include <dinput.h>
#include "MultiDI.h"
#include "resource.h"




//-----------------------------------------------------------------------------
// Defines, and constants
//-----------------------------------------------------------------------------
#define SAMPLE_KEY        TEXT("Software\\Microsoft\\DirectX SDK\\MultiMapper")

// This GUID must be unique for every game, and the same for
// every instance of this app.  // {67131584-2938-4857-8A2E-D99DC2C82068}
// The GUID allows DirectInput to remember input settings
GUID g_guidApp = { 0x67131584, 0x2938, 0x4857, { 0x8a, 0x2e, 0xd9, 0x9d, 0xc2, 0xc8, 0x20, 0x68 } };


// DirectInput action mapper reports events only when buttons/axis change
// so we need to remember the present state of relevant axis/buttons for
// each DirectInput device.  The CMultiplayerInputDeviceManager will store a
// pointer for each device that points to this struct
struct InputDeviceState
{
    FLOAT fAxisMoveUD;
    BOOL  bButtonForwardThrust;
    BOOL  bButtonReverseThrust;

    FLOAT fAxisRotateLR;
    BOOL  bButtonRotateLeft;
    BOOL  bButtonRotateRight;

    BOOL  bButtonFireWeapons;
    BOOL  bButtonEnableShield;
};


// Struct to store the current input state
struct UserInput
{
    FLOAT fAxisMoveUD;
    FLOAT fAxisRotateLR;
    BOOL  bButtonFireWeapons;
    BOOL  bButtonEnableShield;

    BOOL  bDoConfigureInput;
    BOOL  bDoQuitGame;
};


// Input semantics used by this app
enum INPUT_SEMANTICS
{
    // Gameplay semantics
    INPUT_ROTATE_AXIS_LR=1,  INPUT_MOVE_AXIS_UD,
    INPUT_FIREWEAPONS,       INPUT_ENABLESHIELD,
    INPUT_TURNLEFT,          INPUT_TURNRIGHT,
    INPUT_FORWARDTHRUST,     INPUT_REVERSETHRUST,
    INPUT_DISPLAYGAMEMENU,   INPUT_QUITGAME,
};

// Actions used by this app
DIACTION g_rgGameAction[] =
{
    // If DirectInput has already been given an action map for this GUID, it
    // will have created a user map for this application
    // (C:\Program Files\Common Files\DirectX\DirectInput\User Maps\*.ini). If a user map
    // exists, DirectInput will use the action map defined in the stored user
    // map instead of the map defined in your program. This allows the user to
    // customize controls without losing changes when the game restarts. If you
    // wish to make changes to the default action map without changing the
    // GUID, you will need to delete the stored user map from your hard drive
    // for the system to detect your changes and recreate a stored user map.

    // Device input (joystick, etc.) that is pre-defined by DInput, according
    // to genre type. The genre for this app is space simulators.
    { INPUT_ROTATE_AXIS_LR,  DIAXIS_SPACESIM_LATERAL,      0, TEXT("Turn left/right"), },
    { INPUT_MOVE_AXIS_UD,    DIAXIS_SPACESIM_MOVE,         0, TEXT("Move"), },
    { INPUT_FIREWEAPONS,     DIBUTTON_SPACESIM_FIRE,       0, TEXT("Shoot"), },
    { INPUT_ENABLESHIELD,    DIBUTTON_SPACESIM_GEAR,       0, TEXT("Shield"), },
    { INPUT_DISPLAYGAMEMENU, DIBUTTON_SPACESIM_DISPLAY,    0, TEXT("Configure"), },

    // Keyboard input mappings
    { INPUT_TURNLEFT,        DIKEYBOARD_LEFT,    0, TEXT("Turn left"), },
    { INPUT_TURNRIGHT,       DIKEYBOARD_RIGHT,   0, TEXT("Turn right"), },
    { INPUT_FORWARDTHRUST,   DIKEYBOARD_UP,      0, TEXT("Move forward"), },
    { INPUT_REVERSETHRUST,   DIKEYBOARD_DOWN,    0, TEXT("Move backward"), },
    { INPUT_FIREWEAPONS,     DIKEYBOARD_F,       0, TEXT("Fire weapons"), },
    { INPUT_ENABLESHIELD,    DIKEYBOARD_S,       0, TEXT("Enable shields"), },
    { INPUT_DISPLAYGAMEMENU, DIKEYBOARD_D,       DIA_APPFIXED, TEXT("Configure"), },
    { INPUT_QUITGAME,        DIKEYBOARD_ESCAPE,  DIA_APPFIXED, TEXT("Quit game"), },

    // Mouse input mappings
    { INPUT_ROTATE_AXIS_LR,  DIMOUSE_XAXIS,      0, _T("Turn left/right"), },
    { INPUT_MOVE_AXIS_UD,    DIMOUSE_YAXIS,      0, _T("Move"), },
    { INPUT_FIREWEAPONS,     DIMOUSE_BUTTON0,    0, _T("Shoot"), },
    { INPUT_ENABLESHIELD,    DIMOUSE_BUTTON1,    0, _T("Enable shields"), },
};

#define NUMBER_OF_GAMEACTIONS    (sizeof(g_rgGameAction)/sizeof(DIACTION))




//-----------------------------------------------------------------------------
// Function prototypes
//-----------------------------------------------------------------------------
INT_PTR CALLBACK StaticMsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam );




//-----------------------------------------------------------------------------
// Name: class CMyApplication
// Desc: Application class.
//-----------------------------------------------------------------------------
class CMyApplication
{
    TCHAR*                  m_strWindowTitle;       // Title for the app's window
    HWND                    m_hWnd;                 // The main app window
    FLOAT                   m_fTime;                // Current time in seconds
    FLOAT                   m_fElapsedTime;         // Time elapsed since last frame

    CMultiplayerInputDeviceManager* m_pInputDeviceManager;  // DirectInput multiplayer device manager
    DIACTIONFORMAT          m_diafGame;             // Action format for game play
    UserInput               m_UserInput[4];         // Struct for storing user input

    DWORD                   m_dwNumPlayers;         // Number of players in the game
    FLOAT                   m_fWorldRotX;           // World rotation state X-axis
    FLOAT                   m_fWorldRotY;           // World rotation state Y-axis

protected:
    HRESULT OneTimeSceneInit();
    HRESULT Render();
    HRESULT FrameMove();
    HRESULT FinalCleanup();

    HRESULT EnableUI();
    HRESULT RenderText();

    HRESULT InitInput();
    HRESULT ChangeNumPlayers( DWORD dwNumPlayers, BOOL bResetOwnership, BOOL bResetMappings );
    VOID    ConfigInput();
    void    UpdateInput();
    void    CleanupDirectInput();
    void    CleanupDeviceStateStructs();

public:
    HRESULT Create( HINSTANCE hInstance );
    INT     Run();
    INT_PTR MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );

    CMyApplication();

    HRESULT InputAddDeviceCB( CMultiplayerInputDeviceManager::PlayerInfo* pPlayerInfo, CMultiplayerInputDeviceManager::DeviceInfo* pDeviceInfo, const DIDEVICEINSTANCE* pdidi );
    static HRESULT CALLBACK StaticInputAddDeviceCB( CMultiplayerInputDeviceManager::PlayerInfo* pPlayerInfo, CMultiplayerInputDeviceManager::DeviceInfo* pDeviceInfo, const DIDEVICEINSTANCE* pdidi, LPVOID pParam );
};




//-----------------------------------------------------------------------------
// Global access to the app (needed for the global WndProc())
//-----------------------------------------------------------------------------
CMyApplication*    g_pApp  = NULL;
HINSTANCE          g_hInst = NULL;




//-----------------------------------------------------------------------------
// Name: WinMain()
// Desc: Application entry point
//-----------------------------------------------------------------------------
INT WINAPI WinMain( HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow )
{
    CMyApplication app;

    g_hInst = hInstance;

    InitCommonControls();

    if( FAILED( app.Create( hInstance ) ) )
        return 0;

    return app.Run();
}




//-----------------------------------------------------------------------------
// Name: CMyApplication()
// Desc: Constructor
//-----------------------------------------------------------------------------
CMyApplication::CMyApplication()
{
    g_pApp                      = this;
    m_hWnd                      = NULL;
    m_strWindowTitle            = TEXT( "DirectInput MultiMapper Sample" );
    m_pInputDeviceManager       = NULL;

    ZeroMemory( m_UserInput, sizeof(UserInput)*4 );
    m_fWorldRotX                = 0.0f;
    m_fWorldRotY                = 0.0f;
    m_dwNumPlayers              = 1;
}




//-----------------------------------------------------------------------------
// Name: Create()
// Desc: Creates the window
//-----------------------------------------------------------------------------
HRESULT CMyApplication::Create( HINSTANCE hInstance )
{
    // Display the main dialog box.
    CreateDialog( hInstance, MAKEINTRESOURCE(IDD_MAIN),
                  NULL, StaticMsgProc );
    if( NULL == m_hWnd )
        return E_FAIL;

    // Initialize the application timer
    DXUtil_Timer( TIMER_START );

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: Run()
// Desc: Handles the message loop and calls FrameMove() and Render() when
//       idle.
//-----------------------------------------------------------------------------
INT CMyApplication::Run()
{
    MSG msg;

    // Message loop to run the app
    for( ; ; )
    {
        if( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
        {
            // Skip WM_KEYDOWN so they aren't handled by the dialog
            if( msg.message == WM_KEYDOWN )
                continue;

            if( !IsDialogMessage( m_hWnd, &msg ) )
            {
                TranslateMessage( &msg );
                DispatchMessage( &msg );
            }

            if( msg.message == WM_QUIT )
            {
                DestroyWindow( m_hWnd );
                break;
            }
        }
        else
        {
            // Update the time variables
            m_fTime        = DXUtil_Timer( TIMER_GETAPPTIME );
            m_fElapsedTime = DXUtil_Timer( TIMER_GETELAPSEDTIME );

            // This app uses idle time processing for the game loop
            if( FAILED( FrameMove() ) )
                SendMessage( m_hWnd, WM_DESTROY, 0, 0 );
            if( FAILED( Render() ) )
                SendMessage( m_hWnd, WM_DESTROY, 0, 0 );

            Sleep( 20 );
        }
    }

    FinalCleanup();

    return (INT)msg.wParam;
}




//-----------------------------------------------------------------------------
// Name: OneTimeSceneInit()
// Desc: Called during initial app startup, this function performs all the
//       permanent initialization.
//-----------------------------------------------------------------------------
HRESULT CMyApplication::OneTimeSceneInit()
{
    HRESULT hr;

    // Load the icon
    HICON hIcon = LoadIcon( GetModuleHandle(NULL), MAKEINTRESOURCE( IDI_MAIN ) );

    // Set the icon for this dialog.
    SendMessage( m_hWnd, WM_SETICON, ICON_BIG,   (LPARAM) hIcon );  // Set big icon
    SendMessage( m_hWnd, WM_SETICON, ICON_SMALL, (LPARAM) hIcon );  // Set small icon

    // Initialize DirectInput
    if( FAILED( hr = InitInput() ) )
        return DXTRACE_ERR_MSGBOX( TEXT("InitInput"), hr );

    HWND hNumPlayers = GetDlgItem( m_hWnd, IDC_NUM_PLAYERS_COMBO );
    SendMessage( hNumPlayers, CB_ADDSTRING, 0, (LPARAM) TEXT("1") );
    SendMessage( hNumPlayers, CB_ADDSTRING, 0, (LPARAM) TEXT("2") );
    SendMessage( hNumPlayers, CB_ADDSTRING, 0, (LPARAM) TEXT("3") );
    SendMessage( hNumPlayers, CB_ADDSTRING, 0, (LPARAM) TEXT("4") );
    SendMessage( hNumPlayers, CB_SETCURSEL, m_dwNumPlayers-1, 0 );

    EnableUI();

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: InitInput()
// Desc: Initialize DirectInput objects
//-----------------------------------------------------------------------------
HRESULT CMyApplication::InitInput()
{
    HRESULT hr;

    // Setup action format for the actual gameplay
    ZeroMemory( &m_diafGame, sizeof(DIACTIONFORMAT) );
    m_diafGame.dwSize          = sizeof(DIACTIONFORMAT);
    m_diafGame.dwActionSize    = sizeof(DIACTION);
    m_diafGame.dwDataSize      = NUMBER_OF_GAMEACTIONS * sizeof(DWORD);
    m_diafGame.guidActionMap   = g_guidApp;
    m_diafGame.dwGenre         = DIVIRTUAL_SPACESIM;
    m_diafGame.dwNumActions    = NUMBER_OF_GAMEACTIONS;
    m_diafGame.rgoAction       = g_rgGameAction;
    m_diafGame.lAxisMin        = -100;
    m_diafGame.lAxisMax        = 100;
    m_diafGame.dwBufferSize    = 16;
    _tcscpy( m_diafGame.tszActionMap, _T("MultiMapper Sample") );

    // Create a new input device manager
    m_pInputDeviceManager = new CMultiplayerInputDeviceManager( SAMPLE_KEY );

    if( FAILED( hr = ChangeNumPlayers( 1, FALSE, FALSE ) ) )
        return DXTRACE_ERR_MSGBOX( TEXT("ChangeNumPlayers"), hr );

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: StaticInputAddDeviceCB()
// Desc: Static callback helper to call into CMyApplication class
//-----------------------------------------------------------------------------
HRESULT CALLBACK CMyApplication::StaticInputAddDeviceCB(
                                         CMultiplayerInputDeviceManager::PlayerInfo* pPlayerInfo,
                                         CMultiplayerInputDeviceManager::DeviceInfo* pDeviceInfo,
                                         const DIDEVICEINSTANCE* pdidi,
                                         LPVOID pParam )
{
    CMyApplication* pApp = (CMyApplication*) pParam;
    return pApp->InputAddDeviceCB( pPlayerInfo, pDeviceInfo, pdidi );
}




//-----------------------------------------------------------------------------
// Name: InputAddDeviceCB()
// Desc: Called from CMultiplayerInputDeviceManager whenever a device is added.
//       Set the dead zone, and creates a new InputDeviceState for each device
//-----------------------------------------------------------------------------
HRESULT CMyApplication::InputAddDeviceCB( CMultiplayerInputDeviceManager::PlayerInfo* pPlayerInfo,
                                         CMultiplayerInputDeviceManager::DeviceInfo* pDeviceInfo,
                                         const DIDEVICEINSTANCE* pdidi )
{
    if( (GET_DIDEVICE_TYPE(pdidi->dwDevType) != DI8DEVTYPE_KEYBOARD) &&
        (GET_DIDEVICE_TYPE(pdidi->dwDevType) != DI8DEVTYPE_MOUSE) )
    {
        // Setup the deadzone
        DIPROPDWORD dipdw;
        dipdw.diph.dwSize       = sizeof(DIPROPDWORD);
        dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
        dipdw.diph.dwObj        = 0;
        dipdw.diph.dwHow        = DIPH_DEVICE;
        dipdw.dwData            = 500;
        pDeviceInfo->pdidDevice->SetProperty( DIPROP_DEADZONE, &dipdw.diph );
    }

    // Create a new InputDeviceState for each device so the
    // app can record its state
    InputDeviceState* pNewInputDeviceState = new InputDeviceState;
    ZeroMemory( pNewInputDeviceState, sizeof(InputDeviceState) );
    pDeviceInfo->pParam = (LPVOID) pNewInputDeviceState;

    HWND hPlayerDevice = NULL;
    switch( pPlayerInfo->dwPlayerIndex )
    {
    case 0:
        hPlayerDevice = GetDlgItem( m_hWnd, IDC_DEVICE_ASSIGNED_P1 );
        break;
    case 1:
        hPlayerDevice = GetDlgItem( m_hWnd, IDC_DEVICE_ASSIGNED_P2 );
        break;
    case 2:
        hPlayerDevice = GetDlgItem( m_hWnd, IDC_DEVICE_ASSIGNED_P3 );
        break;
    case 3:
        hPlayerDevice = GetDlgItem( m_hWnd, IDC_DEVICE_ASSIGNED_P4 );
        break;
    }

    SendMessage( hPlayerDevice, LB_ADDSTRING, 0, (LPARAM) pdidi->tszProductName );

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: ChangeNumPlayers()
// Desc: Signals a change in the number of players. It is also called to reset
//       ownership and mapping data.
//-----------------------------------------------------------------------------
HRESULT CMyApplication::ChangeNumPlayers( DWORD dwNumPlayers, BOOL bResetOwnership,
                                          BOOL bResetMappings )
{
    HRESULT hr;

    m_dwNumPlayers = dwNumPlayers;

    // Just pass in stock names.  Real games may want to ask the user for a name, etc.
    TCHAR* strUserNames[4] = { TEXT("Player 1"), TEXT("Player 2"),
                               TEXT("Player 3"), TEXT("Player 4") };

    BOOL bSuccess = FALSE;
    while( !bSuccess )
    {
        // Update UI
        EnableUI();
        SendMessage( GetDlgItem(m_hWnd,IDC_DEVICE_ASSIGNED_P1), LB_RESETCONTENT, 0, 0 );
        SendMessage( GetDlgItem(m_hWnd,IDC_DEVICE_ASSIGNED_P2), LB_RESETCONTENT, 0, 0 );
        SendMessage( GetDlgItem(m_hWnd,IDC_DEVICE_ASSIGNED_P3), LB_RESETCONTENT, 0, 0 );
        SendMessage( GetDlgItem(m_hWnd,IDC_DEVICE_ASSIGNED_P4), LB_RESETCONTENT, 0, 0 );

        hr = m_pInputDeviceManager->Create( m_hWnd, strUserNames, m_dwNumPlayers, &m_diafGame,
                                            StaticInputAddDeviceCB, this,
                                            bResetOwnership, bResetMappings );

        if( FAILED(hr) )
        {
            switch( hr )
            {
                case E_DIUTILERR_DEVICESTAKEN:
                {
                    // It's possible that a single user could "own" too many devices for the other
                    // players to get into the game. If so, we reinit the manager class to provide
                    // each user with a device that has a default configuration.
                    bResetOwnership = TRUE;

                    MessageBox( m_hWnd, TEXT("You have entered more users than there are suitable ")       \
                                        TEXT("devices, or some users are claiming too many devices.\n") \
                                        TEXT("Press OK to give each user a default device"),
                                        TEXT("Devices Are Taken"), MB_OK | MB_ICONEXCLAMATION );
                    break;
                }

                case E_DIUTILERR_TOOMANYUSERS:
                {
                    // Another common error is if more users are attempting to play than there are devices
                    // attached to the machine. In this case, the number of players is automatically
                    // lowered to make playing the game possible.
                    DWORD dwNumDevices = m_pInputDeviceManager->GetNumDevices();
                    m_dwNumPlayers = dwNumDevices;
                    SendMessage( GetDlgItem( m_hWnd, IDC_NUM_PLAYERS_COMBO ),
                                 CB_SETCURSEL, m_dwNumPlayers-1, 0 );

                    TCHAR sz[256];
                    wsprintf( sz, TEXT("There are not enough devices attached to the ")          \
                                  TEXT("system for the number of users you entered.\nThe ")      \
                                  TEXT("number of users has been automatically changed to ")     \
                                  TEXT("%i (the number of devices available on the system)."),
                                  m_dwNumPlayers );
                    MessageBox( m_hWnd, sz, _T("Too Many Users"), MB_OK | MB_ICONEXCLAMATION );
                    break;
                }

                default:
                    return DXTRACE_ERR_MSGBOX( TEXT("m_pInputDeviceManager->Create"), hr );
                    break;
            }

            m_pInputDeviceManager->Cleanup();
        }
        else
        {
            bSuccess = TRUE;
        }
    }

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: FrameMove()
// Desc: Called once per frame, the call is the entry point for animating
//       the scene.
//-----------------------------------------------------------------------------
HRESULT CMyApplication::FrameMove()
{
    // Update user input state
    UpdateInput();

    for( DWORD iPlayer=0; iPlayer<m_dwNumPlayers; iPlayer++ )
    {
        // Respond to input
        if( m_UserInput[iPlayer].bDoConfigureInput )
        {
            // One-shot per keypress
            m_UserInput[iPlayer].bDoConfigureInput = FALSE;

            ConfigInput();
        }

        // Update the world state according to user input
        if( m_UserInput[iPlayer].fAxisMoveUD )
            m_fWorldRotY += m_fElapsedTime * m_UserInput[iPlayer].fAxisMoveUD;

        if( m_UserInput[iPlayer].fAxisRotateLR )
            m_fWorldRotX += m_fElapsedTime * m_UserInput[iPlayer].fAxisRotateLR;
    }

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: UpdateInput()
// Desc: Update the user input.  Called once per frame
//-----------------------------------------------------------------------------
void CMyApplication::UpdateInput()
{
    if( NULL == m_pInputDeviceManager )
        return;

    CMultiplayerInputDeviceManager::DeviceInfo* pDeviceInfos;
    DWORD dwNumDevices;

    // Get access to the list of semantically-mapped input devices
    m_pInputDeviceManager->GetDevices( &pDeviceInfos, &dwNumDevices );

    // Loop through all devices and check game input
    for( DWORD i=0; i<dwNumDevices; i++ )
    {
        // skip past any devices that aren't assigned,
        // since we don't care about them
        if( pDeviceInfos[i].pPlayerInfo == NULL )
            continue;

        DIDEVICEOBJECTDATA rgdod[10];
        DWORD   dwItems = 10;
        HRESULT hr;
        LPDIRECTINPUTDEVICE8 pdidDevice = pDeviceInfos[i].pdidDevice;
        InputDeviceState* pInputDeviceState = (InputDeviceState*) pDeviceInfos[i].pParam;
        FLOAT fScale = 1.0f;

        if( pDeviceInfos[i].bRelativeAxis )
        {
            // For relative axis data, the action mapper only informs us when
            // the delta data is non-zero, so we need to zero its state
            // out each frame
            pInputDeviceState->fAxisMoveUD   = 0.0f;
            pInputDeviceState->fAxisRotateLR = 0.0f;

            // Scale the relative axis data to make it more equal to
            // absolute joystick data
            fScale = 5.0f;
        }

        hr = pdidDevice->Acquire();
        hr = pdidDevice->Poll();
        hr = pdidDevice->GetDeviceData( sizeof(DIDEVICEOBJECTDATA),
                                        rgdod, &dwItems, 0 );
        if( FAILED(hr) )
            continue;

        // Get the sematics codes for the game menu
        for( DWORD j=0; j<dwItems; j++ )
        {
            BOOL  bButtonState = (rgdod[j].dwData==0x80) ? TRUE : FALSE;
            FLOAT fAxisState   = (FLOAT)((int)rgdod[j].dwData)/100.0f * fScale;

            switch( rgdod[j].uAppData )
            {
                // Handle relative axis data
                case INPUT_ROTATE_AXIS_LR:
                    pInputDeviceState->fAxisRotateLR = fAxisState;
                    break;
                case INPUT_MOVE_AXIS_UD:
                    pInputDeviceState->fAxisMoveUD = -fAxisState;
                    break;

                // Handle buttons separately so the button state data
                // doesn't overwrite the axis state data, and handle
                // each button separately so they don't overwrite each other
                case INPUT_TURNLEFT:        pInputDeviceState->bButtonRotateLeft    = bButtonState; break;
                case INPUT_TURNRIGHT:       pInputDeviceState->bButtonRotateRight   = bButtonState; break;
                case INPUT_FORWARDTHRUST:   pInputDeviceState->bButtonForwardThrust = bButtonState; break;
                case INPUT_REVERSETHRUST:   pInputDeviceState->bButtonReverseThrust = bButtonState; break;
                case INPUT_FIREWEAPONS:     pInputDeviceState->bButtonFireWeapons   = bButtonState; break;
                case INPUT_ENABLESHIELD:    pInputDeviceState->bButtonEnableShield  = bButtonState; break;

                // Handle one-shot buttons
                case INPUT_DISPLAYGAMEMENU: if( bButtonState ) m_UserInput[0].bDoConfigureInput = TRUE; break;
                case INPUT_QUITGAME:        if( bButtonState ) m_UserInput[0].bDoQuitGame       = TRUE; break;
            }
        }
    }

    for( DWORD iPlayer=0; iPlayer<m_dwNumPlayers; iPlayer++ )
    {
        // Process user input and store result into pUserInput struct
        m_UserInput[iPlayer].fAxisRotateLR = 0.0f;
        m_UserInput[iPlayer].fAxisMoveUD   = 0.0f;
        m_UserInput[iPlayer].bButtonFireWeapons  = FALSE;
        m_UserInput[iPlayer].bButtonEnableShield = FALSE;

        // Concatinate the data from all the DirectInput devices
        for( i=0; i<dwNumDevices; i++ )
        {
            // Only look at devices that are assigned to this player
            if( pDeviceInfos[i].pPlayerInfo == NULL ||
                pDeviceInfos[i].pPlayerInfo->dwPlayerIndex != iPlayer )
                continue;

            InputDeviceState* pInputDeviceState = (InputDeviceState*) pDeviceInfos[i].pParam;

            // Use the axis data that is furthest from zero
            if( fabs(pInputDeviceState->fAxisRotateLR) > fabs(m_UserInput[iPlayer].fAxisRotateLR) )
                m_UserInput[iPlayer].fAxisRotateLR = pInputDeviceState->fAxisRotateLR;

            if( fabs(pInputDeviceState->fAxisMoveUD) > fabs(m_UserInput[iPlayer].fAxisMoveUD) )
                m_UserInput[iPlayer].fAxisMoveUD = pInputDeviceState->fAxisMoveUD;

            // Process the button data
            if( pInputDeviceState->bButtonRotateLeft )
                m_UserInput[iPlayer].fAxisRotateLR = -1.0f;
            else if( pInputDeviceState->bButtonRotateRight )
                m_UserInput[iPlayer].fAxisRotateLR = 1.0f;

            if( pInputDeviceState->bButtonForwardThrust )
                m_UserInput[iPlayer].fAxisMoveUD = 1.0f;
            else if( pInputDeviceState->bButtonReverseThrust )
                m_UserInput[iPlayer].fAxisMoveUD = -1.0f;

            if( pInputDeviceState->bButtonFireWeapons )
                m_UserInput[iPlayer].bButtonFireWeapons = TRUE;
            if( pInputDeviceState->bButtonEnableShield )
                m_UserInput[iPlayer].bButtonEnableShield = TRUE;
        }
    }
}




//-----------------------------------------------------------------------------
// Name: Render()
// Desc: Called once per frame, the call is the entry point for rendering the
//       world.
//-----------------------------------------------------------------------------
HRESULT CMyApplication::Render()
{
    TCHAR szMsg[MAX_PATH];
    TCHAR szMsgCurrent[MAX_PATH];

    // Update Player 1
    _stprintf( szMsg, TEXT("%0.2f"), m_UserInput[0].fAxisMoveUD );
    GetWindowText( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P1), szMsgCurrent, MAX_PATH );
    if( lstrcmp( szMsgCurrent, szMsg ) != 0 )
        SetWindowText( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P1), szMsg );
    _stprintf( szMsg, TEXT("%0.2f"), m_UserInput[0].fAxisRotateLR );
    GetWindowText( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P1), szMsgCurrent, MAX_PATH );
    if( lstrcmp( szMsgCurrent, szMsg ) != 0 )
        SetWindowText( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P1), szMsg );
    if( !m_UserInput[0].bButtonEnableShield && !m_UserInput[0].bButtonFireWeapons )
        _stprintf( szMsg, TEXT("None") );
    else
        _stprintf( szMsg, TEXT("%s%s"), m_UserInput[0].bButtonEnableShield ? TEXT("Shield ") : TEXT(""),
                                      m_UserInput[0].bButtonFireWeapons ? TEXT("Fire ") : TEXT("") );
    GetWindowText( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P1), szMsgCurrent, MAX_PATH );
    if( lstrcmp( szMsgCurrent, szMsg ) != 0 )
        SetWindowText( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P1), szMsg );

    // Update Player 2
    _stprintf( szMsg, TEXT("%0.2f"), m_UserInput[1].fAxisMoveUD );
    GetWindowText( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P2), szMsgCurrent, MAX_PATH );
    if( lstrcmp( szMsgCurrent, szMsg ) != 0 )
        SetWindowText( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P2), szMsg );
    _stprintf( szMsg, TEXT("%0.2f"), m_UserInput[1].fAxisRotateLR );
    GetWindowText( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P2), szMsgCurrent, MAX_PATH );
    if( lstrcmp( szMsgCurrent, szMsg ) != 0 )
        SetWindowText( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P2), szMsg );
    if( !m_UserInput[1].bButtonEnableShield && !m_UserInput[1].bButtonFireWeapons )
        _stprintf( szMsg, TEXT("None") );
    else
        _stprintf( szMsg, TEXT("%s%s"), m_UserInput[1].bButtonEnableShield ? TEXT("Shield ") : TEXT(""),
        m_UserInput[1].bButtonFireWeapons ? TEXT("Fire ") : TEXT("") );
    GetWindowText( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P2), szMsgCurrent, MAX_PATH );
    if( lstrcmp( szMsgCurrent, szMsg ) != 0 )
        SetWindowText( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P2), szMsg );

    // Update Player 3
    _stprintf( szMsg, TEXT("%0.2f"), m_UserInput[2].fAxisMoveUD );
    GetWindowText( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P3), szMsgCurrent, MAX_PATH );
    if( lstrcmp( szMsgCurrent, szMsg ) != 0 )
        SetWindowText( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P3), szMsg );
    _stprintf( szMsg, TEXT("%0.2f"), m_UserInput[2].fAxisRotateLR );
    GetWindowText( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P3), szMsgCurrent, MAX_PATH );
    if( lstrcmp( szMsgCurrent, szMsg ) != 0 )
        SetWindowText( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P3), szMsg );
    if( !m_UserInput[2].bButtonEnableShield && !m_UserInput[2].bButtonFireWeapons )
        _stprintf( szMsg, TEXT("None") );
    else
        _stprintf( szMsg, TEXT("%s%s"), m_UserInput[2].bButtonEnableShield ? TEXT("Shield ") : TEXT(""),
        m_UserInput[2].bButtonFireWeapons ? TEXT("Fire ") : TEXT("") );
    GetWindowText( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P3), szMsgCurrent, MAX_PATH );
    if( lstrcmp( szMsgCurrent, szMsg ) != 0 )
        SetWindowText( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P3), szMsg );

    // Update Player 4
    _stprintf( szMsg, TEXT("%0.2f"), m_UserInput[3].fAxisMoveUD );
    GetWindowText( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P4), szMsgCurrent, MAX_PATH );
    if( lstrcmp( szMsgCurrent, szMsg ) != 0 )
        SetWindowText( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P4), szMsg );
    _stprintf( szMsg, TEXT("%0.2f"), m_UserInput[3].fAxisRotateLR );
    GetWindowText( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P4), szMsgCurrent, MAX_PATH );
    if( lstrcmp( szMsgCurrent, szMsg ) != 0 )
        SetWindowText( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P4), szMsg );
    if( !m_UserInput[3].bButtonEnableShield && !m_UserInput[3].bButtonFireWeapons )
        _stprintf( szMsg, TEXT("None") );
    else
        _stprintf( szMsg, TEXT("%s%s"), m_UserInput[3].bButtonEnableShield ? TEXT("Shield ") : TEXT(""),
        m_UserInput[3].bButtonFireWeapons ? TEXT("Fire ") : TEXT("") );
    GetWindowText( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P4), szMsgCurrent, MAX_PATH );
    if( lstrcmp( szMsgCurrent, szMsg ) != 0 )
        SetWindowText( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P4), szMsg );

    // Update world state
    _stprintf( szMsg, TEXT("%0.3f, %0.3f"), m_fWorldRotX, m_fWorldRotY );
    GetWindowText( GetDlgItem(m_hWnd,IDC_WORLD_STATE), szMsgCurrent, MAX_PATH );
    if( lstrcmp( szMsgCurrent, szMsg ) != 0 )
        SetWindowText( GetDlgItem(m_hWnd,IDC_WORLD_STATE), szMsg );

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: StaticMsgProc()
// Desc: Static msg handler which passes messages to the application class.
//-----------------------------------------------------------------------------
INT_PTR CALLBACK StaticMsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
    return g_pApp->MsgProc( hWnd, uMsg, wParam, lParam );
}




//-----------------------------------------------------------------------------
// Name: MsgProc()
// Desc: Callback for all Windows messages
//-----------------------------------------------------------------------------
INT_PTR CMyApplication::MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    HRESULT hr;

    switch( msg )
    {
        case WM_INITDIALOG:
            m_hWnd = hWnd;

            // Initialize the app's custom scene stuff
            if( FAILED( hr = OneTimeSceneInit() ) )
            {
                DXTRACE_ERR_MSGBOX( TEXT("OneTimeSceneInit"), hr );
                MessageBox( hWnd, TEXT("Error initializing DirectInput.  Sample will now exit."),
                            TEXT("DirectInput Sample"), MB_OK | MB_ICONERROR );
                PostQuitMessage( IDCANCEL );
                return TRUE;
            }
            break;

        case WM_COMMAND:
        {
            switch( LOWORD(wParam) )
            {
            case IDC_NUM_PLAYERS_COMBO:
                {
                    if( HIWORD(wParam) == CBN_SELCHANGE )
                    {
                        TCHAR strItem[MAX_PATH];
                        HWND hNumPlayers = GetDlgItem( m_hWnd, IDC_NUM_PLAYERS_COMBO );

                        int nCurSel = (int) SendMessage( hNumPlayers, CB_GETCURSEL, 0, 0 );
                        SendMessage( hNumPlayers, CB_GETLBTEXT, nCurSel, (LPARAM) strItem );
                        DWORD dwNumPlayers = _ttoi( strItem );

                        if( FAILED( hr = ChangeNumPlayers( dwNumPlayers, FALSE, FALSE ) ) )
                        {
                            PostQuitMessage( IDCANCEL );
                        }
                    }
                    break;
                }

                case IDC_RESET_OWNERSHIP:
                    ChangeNumPlayers( m_dwNumPlayers, TRUE, FALSE );
                    break;

                case IDC_RESET_MAPPINGS:
                    ChangeNumPlayers( m_dwNumPlayers, FALSE, TRUE );
                    break;

                case IDCANCEL:
                    PostQuitMessage( IDCANCEL );
                    break;

                case IDM_CONFIGINPUT:
                    m_UserInput[0].bDoConfigureInput = TRUE;
                    break;
            }
            break;
        }
    }

    return FALSE;
}




//-----------------------------------------------------------------------------
// Name: FinalCleanup()
// Desc: Called before the app exits, this function gives the app the chance
//       to cleanup after itself.
//-----------------------------------------------------------------------------
HRESULT CMyApplication::FinalCleanup()
{
    // Cleanup DirectInput
    CleanupDirectInput();

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: CleanupDirectInput()
// Desc: Cleanup DirectInput
//-----------------------------------------------------------------------------
VOID CMyApplication::CleanupDirectInput()
{
    if( NULL == m_pInputDeviceManager )
        return;

    CleanupDeviceStateStructs();

    // Cleanup DirectX input objects
    SAFE_DELETE( m_pInputDeviceManager );
}




//-----------------------------------------------------------------------------
// Name: CleanupDeviceStateStructs()
// Desc:
//-----------------------------------------------------------------------------
VOID CMyApplication::CleanupDeviceStateStructs()
{
    // Get access to the list of semantically-mapped input devices
    // to delete all InputDeviceState structs before calling ConfigureDevices()
    CMultiplayerInputDeviceManager::DeviceInfo* pDeviceInfos;
    DWORD dwNumDevices;

    m_pInputDeviceManager->GetDevices( &pDeviceInfos, &dwNumDevices );

    for( DWORD i=0; i<dwNumDevices; i++ )
    {
        InputDeviceState* pInputDeviceState = (InputDeviceState*) pDeviceInfos[i].pParam;
        SAFE_DELETE( pInputDeviceState );
        pDeviceInfos[i].pParam = NULL;
    }
}




//-----------------------------------------------------------------------------
// Name: ConfigInput()
// Desc:
//-----------------------------------------------------------------------------
VOID CMyApplication::ConfigInput()
{
    HRESULT hr;

    EnableWindow( m_hWnd, FALSE );

    CleanupDeviceStateStructs();

    // Update UI
    EnableUI();
    SendMessage( GetDlgItem(m_hWnd,IDC_DEVICE_ASSIGNED_P1), LB_RESETCONTENT, 0, 0 );
    SendMessage( GetDlgItem(m_hWnd,IDC_DEVICE_ASSIGNED_P2), LB_RESETCONTENT, 0, 0 );
    SendMessage( GetDlgItem(m_hWnd,IDC_DEVICE_ASSIGNED_P3), LB_RESETCONTENT, 0, 0 );
    SendMessage( GetDlgItem(m_hWnd,IDC_DEVICE_ASSIGNED_P4), LB_RESETCONTENT, 0, 0 );

    // Configure the devices (with edit capability)
    hr = m_pInputDeviceManager->ConfigureDevices( m_hWnd, NULL, NULL, DICD_EDIT, NULL );
    if( FAILED(hr) )
    {
        if( hr == E_DIUTILERR_PLAYERWITHOUTDEVICE )
        {
            // There's a player that hasn't been assigned a device.  Some games may
            // want to handle this by reducing the number of players, or auto-assigning
            // a device, or warning the user, etc.
            MessageBox( m_hWnd, TEXT("There is at least one player that wasn't assigned ") \
                                TEXT("a device\n") \
                                TEXT("Press OK to auto-assign a device to these users"),
                                TEXT("Player Without Device"), MB_OK | MB_ICONEXCLAMATION );
        }

        // Auto-reassign every player a device.
        ChangeNumPlayers( m_dwNumPlayers, FALSE, FALSE );
    }

    EnableWindow( m_hWnd, TRUE );
    SetForegroundWindow( m_hWnd );
}




//-----------------------------------------------------------------------------
// Name: EnableUI()
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMyApplication::EnableUI()
{
    BOOL bEnablePlayer4 = ( m_dwNumPlayers > 3 );
    BOOL bEnablePlayer3 = ( m_dwNumPlayers > 2 );
    BOOL bEnablePlayer2 = ( m_dwNumPlayers > 1 );

    // Enable/disable the player 2 ui
    EnableWindow( GetDlgItem(m_hWnd,IDC_TEXT1_P2), bEnablePlayer2 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_TEXT2_P2), bEnablePlayer2 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_TEXT3_P2), bEnablePlayer2 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_PLAYER2_GROUP),    bEnablePlayer2 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P2), bEnablePlayer2 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P2), bEnablePlayer2 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P2),  bEnablePlayer2 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_DEVICE_ASSIGNED_P2),  bEnablePlayer2 );
    if( !bEnablePlayer2 )
    {
        SetWindowText( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P2), TEXT("n/a") );
        SetWindowText( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P2), TEXT("n/a") );
        SetWindowText( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P2),  TEXT("n/a") );
    }

    // Enable/disable the player 3 ui
    EnableWindow( GetDlgItem(m_hWnd,IDC_TEXT1_P3), bEnablePlayer3 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_TEXT2_P3), bEnablePlayer3 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_TEXT3_P3), bEnablePlayer3 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_PLAYER3_GROUP),    bEnablePlayer3 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P3), bEnablePlayer3 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P3), bEnablePlayer3 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P3),  bEnablePlayer3 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_DEVICE_ASSIGNED_P3),  bEnablePlayer3 );
    if( !bEnablePlayer4 )
    {
        SetWindowText( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P3), TEXT("n/a") );
        SetWindowText( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P3), TEXT("n/a") );
        SetWindowText( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P3),  TEXT("n/a") );
    }

    // Enable/disable the player 4 ui
    EnableWindow( GetDlgItem(m_hWnd,IDC_TEXT1_P4), bEnablePlayer4 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_TEXT2_P4), bEnablePlayer4 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_TEXT3_P4), bEnablePlayer4 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_PLAYER4_GROUP),    bEnablePlayer4 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P4), bEnablePlayer4 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P4), bEnablePlayer4 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P4),  bEnablePlayer4 );
    EnableWindow( GetDlgItem(m_hWnd,IDC_DEVICE_ASSIGNED_P4), bEnablePlayer4 );
    if( !bEnablePlayer4 )
    {
        SetWindowText( GetDlgItem(m_hWnd,IDC_UD_AXIS_STATE_P4), TEXT("n/a") );
        SetWindowText( GetDlgItem(m_hWnd,IDC_LR_AXIS_STATE_P4), TEXT("n/a") );
        SetWindowText( GetDlgItem(m_hWnd,IDC_BUTTON_STATE_P4),  TEXT("n/a") );
    }

    return S_OK;
}






//-----------------------------------------------------------------------------
// Name: DXUtil_Timer()
// Desc: Performs timer opertations. Use the following commands:
//          TIMER_RESET           - to reset the timer
//          TIMER_START           - to start the timer
//          TIMER_STOP            - to stop (or pause) the timer
//          TIMER_ADVANCE         - to advance the timer by 0.1 seconds
//          TIMER_GETABSOLUTETIME - to get the absolute system time
//          TIMER_GETAPPTIME      - to get the current time
//          TIMER_GETELAPSEDTIME  - to get the time that elapsed between
//                                  TIMER_GETELAPSEDTIME calls
//-----------------------------------------------------------------------------
FLOAT __stdcall DXUtil_Timer( TIMER_COMMAND command )
{
    static BOOL     m_bTimerInitialized = FALSE;
    static BOOL     m_bUsingQPF         = FALSE;
    static BOOL     m_bTimerStopped     = TRUE;
    static LONGLONG m_llQPFTicksPerSec  = 0;

    // Initialize the timer
    if( FALSE == m_bTimerInitialized )
    {
        m_bTimerInitialized = TRUE;

        // Use QueryPerformanceFrequency() to get frequency of timer.  If QPF is
        // not supported, we will timeGetTime() which returns milliseconds.
        LARGE_INTEGER qwTicksPerSec;
        m_bUsingQPF = QueryPerformanceFrequency( &qwTicksPerSec );
        if( m_bUsingQPF )
            m_llQPFTicksPerSec = qwTicksPerSec.QuadPart;
    }

    if( m_bUsingQPF )
    {
        static LONGLONG m_llStopTime        = 0;
        static LONGLONG m_llLastElapsedTime = 0;
        static LONGLONG m_llBaseTime        = 0;
        double fTime;
        double fElapsedTime;
        LARGE_INTEGER qwTime;

        // Get either the current time or the stop time, depending
        // on whether we're stopped and what command was sent
        if( m_llStopTime != 0 && command != TIMER_START && command != TIMER_GETABSOLUTETIME)
            qwTime.QuadPart = m_llStopTime;
        else
            QueryPerformanceCounter( &qwTime );

        // Return the elapsed time
        if( command == TIMER_GETELAPSEDTIME )
        {
            fElapsedTime = (double) ( qwTime.QuadPart - m_llLastElapsedTime ) / (double) m_llQPFTicksPerSec;
            m_llLastElapsedTime = qwTime.QuadPart;
            return (FLOAT) fElapsedTime;
        }

        // Return the current time
        if( command == TIMER_GETAPPTIME )
        {
            double fAppTime = (double) ( qwTime.QuadPart - m_llBaseTime ) / (double) m_llQPFTicksPerSec;
            return (FLOAT) fAppTime;
        }

        // Reset the timer
        if( command == TIMER_RESET )
        {
            m_llBaseTime        = qwTime.QuadPart;
            m_llLastElapsedTime = qwTime.QuadPart;
            m_llStopTime        = 0;
            m_bTimerStopped     = FALSE;
            return 0.0f;
        }

        // Start the timer
        if( command == TIMER_START )
        {
            if( m_bTimerStopped )
                m_llBaseTime += qwTime.QuadPart - m_llStopTime;
            m_llStopTime = 0;
            m_llLastElapsedTime = qwTime.QuadPart;
            m_bTimerStopped = FALSE;
            return 0.0f;
        }

        // Stop the timer
        if( command == TIMER_STOP )
        {
            if( !m_bTimerStopped )
            {
                m_llStopTime = qwTime.QuadPart;
                m_llLastElapsedTime = qwTime.QuadPart;
                m_bTimerStopped = TRUE;
            }
            return 0.0f;
        }

        // Advance the timer by 1/10th second
        if( command == TIMER_ADVANCE )
        {
            m_llStopTime += m_llQPFTicksPerSec/10;
            return 0.0f;
        }

        if( command == TIMER_GETABSOLUTETIME )
        {
            fTime = qwTime.QuadPart / (double) m_llQPFTicksPerSec;
            return (FLOAT) fTime;
        }

        return -1.0f; // Invalid command specified
    }
    else
    {
        // Get the time using timeGetTime()
        static double m_fLastElapsedTime  = 0.0;
        static double m_fBaseTime         = 0.0;
        static double m_fStopTime         = 0.0;
        double fTime;
        double fElapsedTime;

        // Get either the current time or the stop time, depending
        // on whether we're stopped and what command was sent
        if( m_fStopTime != 0.0 && command != TIMER_START && command != TIMER_GETABSOLUTETIME)
            fTime = m_fStopTime;
        else
            fTime = GetTickCount() * 0.001;

        // Return the elapsed time
        if( command == TIMER_GETELAPSEDTIME )
        {
            fElapsedTime = (double) (fTime - m_fLastElapsedTime);
            m_fLastElapsedTime = fTime;
            return (FLOAT) fElapsedTime;
        }

        // Return the current time
        if( command == TIMER_GETAPPTIME )
        {
            return (FLOAT) (fTime - m_fBaseTime);
        }

        // Reset the timer
        if( command == TIMER_RESET )
        {
            m_fBaseTime         = fTime;
            m_fLastElapsedTime  = fTime;
            m_fStopTime         = 0;
            m_bTimerStopped     = FALSE;
            return 0.0f;
        }

        // Start the timer
        if( command == TIMER_START )
        {
            if( m_bTimerStopped )
                m_fBaseTime += fTime - m_fStopTime;
            m_fStopTime = 0.0f;
            m_fLastElapsedTime  = fTime;
            m_bTimerStopped = FALSE;
            return 0.0f;
        }

        // Stop the timer
        if( command == TIMER_STOP )
        {
            if( !m_bTimerStopped )
            {
                m_fStopTime = fTime;
                m_fLastElapsedTime  = fTime;
                m_bTimerStopped = TRUE;
            }
            return 0.0f;
        }

        // Advance the timer by 1/10th second
        if( command == TIMER_ADVANCE )
        {
            m_fStopTime += 0.1f;
            return 0.0f;
        }

        if( command == TIMER_GETABSOLUTETIME )
        {
            return (FLOAT) fTime;
        }

        return -1.0f; // Invalid command specified
    }
}




//-----------------------------------------------------------------------------
// Name: DXUtil_ConvertGUIDToStringCch()
// Desc: Converts a GUID to a string
//       cchDestChar is the size in TCHARs of strDest.  Be careful not to
//       pass in sizeof(strDest) on UNICODE builds
//-----------------------------------------------------------------------------
HRESULT DXUtil_ConvertGUIDToStringCch( const GUID* pGuidSrc, TCHAR* strDest, int cchDestChar )
{
    int nResult = _sntprintf( strDest, cchDestChar, TEXT("{%0.8X-%0.4X-%0.4X-%0.2X%0.2X-%0.2X%0.2X%0.2X%0.2X%0.2X%0.2X}"),
               pGuidSrc->Data1, pGuidSrc->Data2, pGuidSrc->Data3,
               pGuidSrc->Data4[0], pGuidSrc->Data4[1],
               pGuidSrc->Data4[2], pGuidSrc->Data4[3],
               pGuidSrc->Data4[4], pGuidSrc->Data4[5],
               pGuidSrc->Data4[6], pGuidSrc->Data4[7] );

    if( nResult < 0 )
        return E_FAIL;
    return S_OK;
}


//-----------------------------------------------------------------------------
// Name: DXUtil_ConvertWideStringToAnsi()
// Desc: This is a UNICODE conversion utility to convert a WCHAR string into a
//       CHAR string.
//       cchDestChar is the size in TCHARs of strDestination
//-----------------------------------------------------------------------------
HRESULT DXUtil_ConvertWideStringToAnsiCch( CHAR* strDestination, const WCHAR* wstrSource,
                                     int cchDestChar )
{
    if( strDestination==NULL || wstrSource==NULL || cchDestChar < 1 )
        return E_INVALIDARG;

    int nResult = WideCharToMultiByte( CP_ACP, 0, wstrSource, -1, strDestination,
                                       cchDestChar*sizeof(CHAR), NULL, NULL );
    strDestination[cchDestChar-1] = 0;

    if( nResult == 0 )
        return E_FAIL;
    return S_OK;
}


//-----------------------------------------------------------------------------
// Name: DXUtil_ConvertAnsiStringToGeneric()
// Desc: This is a UNICODE conversion utility to convert a WCHAR string into a
//       TCHAR string.
//       cchDestChar is the size in TCHARs of tstrDestination.  Be careful not to
//       pass in sizeof(strDest) on UNICODE builds
//-----------------------------------------------------------------------------
HRESULT DXUtil_ConvertWideStringToGenericCch( TCHAR* tstrDestination, const WCHAR* wstrSource,
                                           int cchDestChar )
{
    if( tstrDestination==NULL || wstrSource==NULL || cchDestChar < 1 )
        return E_INVALIDARG;

#ifdef _UNICODE
    wcsncpy( tstrDestination, wstrSource, cchDestChar );
    tstrDestination[cchDestChar-1] = L'\0';
    return S_OK;
#else
    return DXUtil_ConvertWideStringToAnsiCch( tstrDestination, wstrSource, cchDestChar );
#endif
}



//-----------------------------------------------------------------------------
// Name: DXUtil_ReadStringRegKeyCch()
// Desc: Helper function to read a registry key string
//       cchDest is the size in TCHARs of strDest.  Be careful not to
//       pass in sizeof(strDest) on UNICODE builds.
//-----------------------------------------------------------------------------
HRESULT DXUtil_ReadStringRegKeyCch( HKEY hKey, LPCTSTR strRegName, TCHAR* strDest,
                                    DWORD cchDest, LPCTSTR strDefault )
{
    DWORD dwType;
    DWORD cbDest = cchDest * sizeof(TCHAR);

    if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType,
                                          (BYTE*)strDest, &cbDest ) )
    {
        _tcsncpy( strDest, strDefault, cchDest );
        strDest[cchDest-1] = 0;
        return S_FALSE;
    }
    else
    {
        if( dwType != REG_SZ )
        {
            _tcsncpy( strDest, strDefault, cchDest );
            strDest[cchDest-1] = 0;
            return S_FALSE;
        }
    }

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: DXUtil_WriteStringRegKey()
// Desc: Helper function to write a registry key string
//-----------------------------------------------------------------------------
HRESULT DXUtil_WriteStringRegKey( HKEY hKey, LPCTSTR strRegName,
                                  LPCTSTR strValue )
{
    if( NULL == strValue )
        return E_INVALIDARG;

    DWORD cbValue = ((DWORD)_tcslen(strValue)+1) * sizeof(TCHAR);

    if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_SZ,
                                        (BYTE*)strValue, cbValue ) )
        return E_FAIL;

    return S_OK;
}